// 包申明
package main

//包导入
import (
	"fmt"
	"unsafe"
)

//main函数
func main() {
	base()
	fmt.Println("Hello World!")
	// 声明一个变量并初始化
	var a = "RUNOOB"
	fmt.Println(a)

	// 没有初始化就为零值
	var b int
	fmt.Println(b)

	// bool 零值为 false
	var c bool
	fmt.Println(c)

	var f float64

	var s string
	fmt.Printf("%v %v %v %q\n", b, f, c, s)

	constDemo()
	constEnumDemo()
	constIotaDemo()
	constIotaDemo02()
	pointerDemo()
}

func base() {
	//变量声明 声明的变量如果不被使用则编译报错
	//var age int = 22
	var apples, oranges string = "苹果", "橘子"
	// + 字符串连接 同 java
	var fruit = apples + oranges
	var color string = `red,
	green`
	fmt.Println(fruit)
	fmt.Println(color)
}

/**
 *常量示例
 */
func constDemo() {
	const LENGTH int = 10
	const WIDTH int = 5
	var area int
	const a, b, c = 1, false, "str" //多重赋值

	area = LENGTH * WIDTH
	fmt.Printf("面积为 : %d", area)
	println()
	println(a, b, c)
}

/**
 * 常量枚举
 */
func constEnumDemo() {
	const (
		a = "abc"
		b = len(a)
		c = unsafe.Sizeof(a)
	)
	println(a, b, c)
}

/**
 *  特殊常量iota
 */
func constIotaDemo() {
	const (
		a = iota //0
		b        //1
		c        //2
		d = "ha" //独立值，iota += 1
		e        //"ha"   iota += 1
		f = 100  //iota +=1
		g        //100  iota +=1
		h = iota //7,恢复计数
		i        //8
	)
	println(a, b, c, d, e, f, g, h, i)
}

func constIotaDemo02() {
	const (
		i = 1 << iota
		j = 3 << iota
		k
		l
	)

	println("i=", i)
	println("j=", j)
	println("k=", k)
	println("l=", l)
}

/**
 * 指针demo
 */
func pointerDemo() {
	var a int = 4
	var b int32
	var c float32
	var ptr *int

	/*
	 * new 内建函数
	 * 使用表达式 new(Type) 将创建一个Type类型的匿名变量，初始化为Type类型的零值，然后返回变量地址，返回的指针类型为*Type
	 */
	newPtr := new(int)
	newPtr = &a
	fmt.Printf("内建函数newPtr 地址：%v, 值:%d", newPtr, *newPtr)

	/* 运算符实例 */
	fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a)
	fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b)
	fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c)

	/*  & 和 * 运算符实例 */
	ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
	fmt.Printf("a 的值为  %d\n", a)
	fmt.Printf("*ptr 为 %d\n", *ptr)
}
